const mongoose = require("mongoose");
const { AuthorSchema } = require("../DBModel/Author");
const {
  isAuthorExist,
  isCollectFolderExists,
  getArticleDetail,
  deleteArticleById,
  deleteDraft,
  deleteArticleFromAuthor,
} = require("./DBcommentApi");

// 通过作者ID获取作者信息，查询成功返回作者信息，失败返回null
const getAuthorInfoById = async (authorId) => {
  try {
    // 使用模型
    const Author = mongoose.model("Author", AuthorSchema);

    // 找到作者信息
    const author = await Author.findOne({ email: authorId });

    // 找不到作者信息
    if (!author) {
      console.log("找不到作者信息", authorId);
      return null;
    }

    // 返回作者信息
    return author;
  } catch (error) {
    console.log(error);
    return null;
  }
};

// 添加文章到作者的文章列表
// 将文章ID添加到作者的文章列表中，成功返回更新结果，失败返回null
const addArticleToAuthor = async (authorId, articleId) => {
  try {
    // 使用模型
    const Author = mongoose.model("Author", AuthorSchema);

    // 查找作者
    const author = await isAuthorExist(authorId);

    // 作者不存在
    if (!author) {
      console.log("作者不存在", authorId);
      return null;
    }

    // 文章列表中已有文章
    if (author.articles.includes(articleId)) {
      console.log("作者文章列表中已有文章", authorId, articleId);
      return null;
    }

    // 更新作者文章列表
    const result = await Author.updateOne(
      { email: authorId },
      { $push: { articles: articleId } }
    );

    // 更新失败
    if (!result.modifiedCount) {
      // modifiedCount 0表示没有更新，其他数字表示更新了多少条数据
      console.log("作者文章列表中已有文章", authorId, articleId);
      return null;
    }

    // 返回更新结果
    return result;
  } catch (error) {
    console.log(error);

    return null;
  }
};

// 添加作者，成功返回作者信息，失败返回null
const addAuthor = async (authorInfo) => {
  try {
    // 使用模型
    const Author = mongoose.model("Author", AuthorSchema);

    // 新建作者
    const author = new Author({
      nickname: authorInfo.nickname || "", // 昵称
      email: authorInfo.email, // 邮箱，作为作者ID
      password: authorInfo.password, // 密码
      articles: authorInfo.articles || [], // 文章列表
      drafts: authorInfo.drafts || [], // 草稿列表
      likesList: authorInfo.likesList || [], // 点赞列表
      avatar: authorInfo.avatar || "", // 头像
      description: authorInfo.description || "", // 简介
      createTime: authorInfo.createTime || new Date(), // 创建时间
      fans: authorInfo.fans || [], // 粉丝列表
      followers: authorInfo.followers || [], // 关注者列表
      collectList: authorInfo.collectList || [], // 收藏列表
    });

    // 保存作者
    const result = await author.save();

    // 返回作者信息
    return result;
  } catch (error) {
    console.log("error", error);
    return false;
  }
};

// 删除作者，成功返回删除结果，失败返回null
const deleteAuthorById = async (authorEmail) => {
  try {
    // 使用模型
    const Author = mongoose.model("Author", AuthorSchema);

    // 找到作者信息
    const author = await Author.findOne({ email: authorEmail });

    // 作者不存在
    if (!author) {
      console.log("删除时发现作者不存在", authorEmail);
      return null;
    }

    // 先删除作者的所有文章
    const promises = author.articles.map(async (articleId) => {
      const res = await deleteArticleById(articleId, authorEmail);
      if (!res) {
        console.log(`删除文章失败，articleId ${articleId}`);
      }
    });

    // 删除作者的草稿
    // const draftPromises = author.drafts.map(async (draftId) => {

    // 使用 Promise.all 确保所有文章都删除完毕
    await Promise.all(promises);

    // 删除作者
    const result = await Author.deleteOne({ email: authorEmail });

    // 删除作者失败
    if (!result.deletedCount) {
      console.log("删除作者失败", authorEmail);
      return null;
    }

    // 返回删除结果
    return result;
  } catch (error) {
    console.log("error", error);
    return false;
  }
};

// 修改作者信息，成功返回更新结果，失败返回null
// 这个函数只能更新作者的昵称、密码、简介
// 作者的其他的信息需要通过其他API接口来更新
const updataAuthorInfo = async (email, newAuthorInfo) => {
  try {
    // 使用模型
    const Author = mongoose.model("Author", AuthorSchema);

    // 判断作者是否存在
    const author = await isAuthorExist(email);

    // 作者不存在
    if (!author) {
      console.log("作者不存在", email);
      return null;
    }

    // 更新作者信息
    const result = await Author.updateOne(
      { email: email },
      {
        $set: {
          nickname: newAuthorInfo.nickname || author.nickname,
          password: newAuthorInfo.password || author.password,
          description: newAuthorInfo.description || author.description,
        },
      }
    );

    // 查找作者信息失败
    // modifiedCount 0表示没有更新，其他数字表示更新了多少条数据
    if (!result.modifiedCount) {
      console.log("作者信息未更新", email);
      return null;
    }

    // 返回更新结果
    return result;
  } catch (error) {
    console.log("error", error);
    return false;
  }
};

// 作者的点赞列表增加文章ID，点赞成功返回更新结果，失败返回null
// 这个点赞列表是为了防止用户重复点赞同一篇文章，所以需要记录用户已经点赞过的文章ID
const addLikeToAuthor = async (authorEmail, articleId) => {
  try {
    // 使用模型
    const Author = mongoose.model("Author", AuthorSchema);

    // 查找作者是否存在
    const author = await isAuthorExist(authorEmail);

    // 作者不存在
    if (!author) {
      console.log("作者不存在", authorEmail);
      return null;
    }

    // 查看作者的点赞列表中是否有文章的ID
    if (author.likesList.includes(articleId)) {
      console.log("作者的点赞列表中已有文章", authorEmail, articleId);
      return null;
    }

    // 更新作者点赞列表
    const result = await Author.updateOne(
      { email: authorEmail },
      { $push: { likesList: articleId } }
    );

    // 返回更新结果
    return result;
  } catch (error) {
    console.log("error", error);
    return false;
  }
};

// 作者的点赞列表删除文章ID
const deleteLikeFromAuthor = async (authorEmail, articleId) => {
  try {
    // 使用模型
    const Author = mongoose.model("Author", AuthorSchema);

    // 查找作者是否存在
    const author = await isAuthorExist(authorEmail);

    // 作者不存在
    if (!author) {
      console.log("作者不存在", authorEmail);
      return null;
    }

    // 查看作者的点赞列表中是否有文章的ID
    if (!author.likesList.includes(articleId)) {
      console.log("作者的点赞列表中没有找到文章", authorEmail, articleId);
      return null;
    }

    // 更新作者点赞列表
    const result = await Author.updateOne(
      { email: authorEmail },
      { $pull: { likesList: articleId } }
    );

    // 返回更新结果
    return result;
  } catch (error) {
    console.log("error", error);
    return false;
  }
};

// 获取作者的文章列表，成功返回文章大概信息列表，失败返回null
const getAuthorArticleList = async (authorEmail) => {
  try {
    // 使用模型
    const Author = mongoose.model("Author", AuthorSchema);

    // 找到作者信息
    const author = await isAuthorExist(authorEmail);

    // 作者不存在
    if (!author) {
      console.log("作者不存在", authorEmail);
      return null;
    }

    // 构造文章列表
    const articlePromises = author.articles.map(async (articleId) => {
      const article = await getArticleDetail(articleId);
      return {
        _id: article._id,
        title: article.title,
        summary: article.summary,
        authorNickName: article.authorNickName,
        authorEmail: article.authorEmail,
        views: article.views,
        likes: article.likes,
        collects: article.collects,
        // 这个评论数还是有一点缺陷，就是没有评论的回复的数量，只有当前文章的评论数
        comments: article.commentList.length,
      };
    });

    // 等待所有文章详情查询完成
    const articleList = await Promise.all(articlePromises);

    // 返回作者文章列表
    return articleList;
  } catch (error) {
    console.log("error", error);
    return false;
  }
};

// 修改作者头像地址，成功返回更新结果，失败返回null
const updataAuthorAvatar = async (email, newAvatar) => {
  try {
    // 使用模型
    const Author = mongoose.model("Author", AuthorSchema);

    // 判断作者是否存在
    const author = await isAuthorExist(email);

    // 作者不存在
    if (!author) {
      console.log("作者不存在", email);
      return null;
    }

    // 更新作者头像地址
    const result = await Author.updateOne(
      { email: email },
      { $set: { avatar: newAvatar } }
    );

    // 查找作者信息失败
    // modifiedCount 0表示没有更新，其他数字表示更新了多少条数据
    if (!result.modifiedCount) {
      console.log("作者头像未更新", email);
      return null;
    }

    // 返回更新结果
    return result;
  } catch (error) {
    console.log("error", error);
    return false;
  }
};

// 关注操作，关注成功返回true，失败返回null（未测试）
const followAuthor = async (follwerEmail, authorEmail) => {
  try {
    // 使用模型
    const Author = mongoose.model("Author", AuthorSchema);

    // 找到作者信息
    const follwer = await isAuthorExist(follwerEmail);
    const author = await isAuthorExist(authorEmail);

    // 作者或者粉丝不存在
    if (!follwer || !author) {
      console.log("作者或者粉丝不存在", follwerEmail, authorEmail);
      return null;
    }

    // 查看粉丝是否已经关注过作者
    if (follwer.followers.includes(author.email)) {
      console.log("粉丝已经关注过作者", follwer.email, author.email);
      return null;
    }
    if (author.fans.includes(follwer.email)) {
      console.log("作者已经被粉丝关注", author.email, follwer.email);
      return null;
    }

    // 关注操做
    const result1 = await Author.updateOne(
      { email: follwer.email },
      { $push: { followers: author.email } }
    );
    const result2 = await Author.updateOne(
      { email: author.email },
      { $push: { fans: follwer.email } }
    );

    // 更新失败
    if (!result1.modifiedCount || !result2.modifiedCount) {
      console.log("关注失败", follwer.email, author.email);
      return null;
    }

    // 返回更新结果
    return result1 && result2;
  } catch (error) {
    console.log("error", error);
    return null;
  }
};

// 取消关注操作，取消关注成功返回true，失败返回null（未测试）
const unfollowAuthor = async (follwerEmail, authorEmail) => {
  try {
    // 使用模型
    const Author = mongoose.model("Author", AuthorSchema);

    // 找到作者信息
    const follwer = await isAuthorExist(follwerEmail);
    const author = await isAuthorExist(authorEmail);

    // 作者或者粉丝不存在
    if (!follwer || !author) {
      console.log("作者或者粉丝不存在", follwerEmail, authorEmail);
      return null;
    }

    // 查看粉丝是否已经关注过作者
    if (!follwer.followers.includes(author.email)) {
      console.log("粉丝没有关注过作者", follwerEmail, authorEmail);
      return null;
    }
    if (!author.fans.includes(follwer.email)) {
      console.log("作者没有被粉丝关注", authorEmail, follwerEmail);
      return null;
    }

    // 取消关注操做
    const result1 = await Author.updateOne(
      { email: follwer.email },
      { $pull: { followers: author.email } }
    );
    const result2 = await Author.updateOne(
      { email: author.email },
      { $pull: { fans: follwer.email } }
    );

    // 更新失败
    if (!result1.modifiedCount || !result2.modifiedCount) {
      console.log("取消关注失败", follwerEmail, authorEmail);
      return null;
    }

    // 返回更新结果
    return result1 && result2;
  } catch (error) {
    console.log("error", error);
    return null;
  }
};

// 添加收藏夹，成功返回更新结果，失败返回null
const addCollectFolder = async (authorEmail, folderName) => {
  try {
    // 使用模型
    const Author = mongoose.model("Author", AuthorSchema);

    // 找到作者信息
    const author = await isAuthorExist(authorEmail);

    // 作者不存在
    if (!author) {
      console.log("作者不存在", authorEmail);
      return null;
    }

    // 获取作者是否已经有同名收藏夹
    const folderExistsResult = await isCollectFolderExists(author, folderName);

    // 判断作者是否有同名收藏夹
    if (folderExistsResult) {
      console.log("作者已经有同名收藏夹", authorEmail, folderName);
      return null;
    }

    // 添加收藏夹
    const result = await Author.updateOne(
      { email: authorEmail },
      {
        $push: {
          collectList: {
            folderName: folderName,
            articleList: [],
          },
        },
      }
    );

    // 更新失败
    if (!result.modifiedCount) {
      console.log("添加收藏夹失败", authorEmail, folderName);
      return null;
    }

    // 返回更新结果
    return result;
  } catch (error) {
    console.log("error", error);
    return null;
  }
};

// 删除收藏夹，成功返回更新结果，失败返回null
const deleteCollectFolder = async (authorEmail, folderName) => {
  try {
    // 使用模型
    const Author = mongoose.model("Author", AuthorSchema);

    // 找到作者信息
    const author = await isAuthorExist(authorEmail);

    // 作者不存在
    if (!author) {
      console.log("作者不存在", authorEmail);
      return null;
    }

    // 获取作者是否有该收藏夹
    const folderExistsResult = await isCollectFolderExists(author, folderName);

    // 作者没有该收藏夹
    if (!folderExistsResult) {
      console.log("作者没有该收藏夹", authorEmail, folderName);
      return null;
    }

    // 删除收藏夹
    const result = await Author.updateOne(
      { email: authorEmail },
      { $pull: { collectList: { folderName: folderName } } }
    );

    // 更新失败
    if (!result.modifiedCount) {
      console.log("删除收藏夹失败", authorEmail, folderName);
      return null;
    }

    // 返回更新结果
    return result;
  } catch (error) {
    console.log("error", error);
    return null;
  }
};

// 向对应的收藏夹中添加文章，成功返回更新后的结果，失败返回null
// 有缺陷，文章是否存在没有得到验证
const addArticleToCollectFolder = async (
  authorEmail,
  folderName,
  articleId
) => {
  try {
    // 使用模型
    const Author = mongoose.model("Author", AuthorSchema);

    // 找到作者信息
    const author = await isAuthorExist(authorEmail);

    // 作者不存在
    if (!author) {
      console.log("作者不存在", authorEmail);
      return null;
    }

    // 获取作者是否有该收藏夹
    const folderExistsResult = await isCollectFolderExists(author, folderName);

    // 判断作者没有该收藏夹
    if (!folderExistsResult) {
      console.log("作者没有该收藏夹", authorEmail, folderName);
      return null;
    }

    // 查看文章是否已经在收藏夹中
    if (
      author.collectList.some(
        (item) =>
          item.folderName === folderName && item.collectItem.includes(articleId)
      )
    ) {
      console.log("文章已经在收藏夹中", authorEmail, folderName, articleId);
      return null;
    }

    // 添加文章到收藏夹，并返回更新后的文档
    const updatedAuthor = await Author.findOneAndUpdate(
      { email: authorEmail, "collectList.folderName": folderName },
      { $addToSet: { "collectList.$[elem].collectItem": articleId } },
      {
        new: true, // 返回更新后的文档
        arrayFilters: [{ "elem.folderName": folderName }],
      }
    );

    // 更新失败
    if (!updatedAuthor) {
      console.log("添加文章到收藏夹失败", authorEmail, folderName, articleId);
      return null;
    }

    // 返回更新后的文章
    const updatedArticle = updatedAuthor.collectList.find(
      (item) => item.folderName === folderName
    );

    return updatedArticle;
  } catch (error) {
    console.log("error", error);
    return null;
  }
};

// 从对应的收藏夹中删除文章，成功返回更新结果，失败返回null
const deleteArticleFromCollectFolder = async (
  authorEmail,
  folderName,
  articleId
) => {
  try {
    // 使用模型
    const Author = mongoose.model("Author", AuthorSchema);

    // 找到作者信息
    const author = await isAuthorExist(authorEmail);

    // 作者不存在
    if (!author) {
      console.log("作者不存在", authorEmail);
      return null;
    }

    // 获取作者是否有该收藏夹
    const folderExistsResult = await isCollectFolderExists(author, folderName);

    // 作者没有该收藏夹
    if (!folderExistsResult) {
      console.log("作者没有该收藏夹", authorEmail, folderName);
      return null;
    }

    // 查看文章是否在收藏夹中
    if (
      !author.collectList.some(
        (item) =>
          item.folderName === folderName && item.collectItem.includes(articleId)
      )
    ) {
      console.log("文章不在收藏夹中", authorEmail, folderName, articleId);
      return null;
    }

    // 删除文章从收藏夹
    const result = await Author.updateOne(
      { email: authorEmail, "collectList.folderName": folderName },
      { $pull: { "collectList.$[elem].collectItem": articleId } },
      { arrayFilters: [{ "elem.folderName": folderName }] }
    );

    // 更新失败
    if (!result.modifiedCount) {
      console.log("删除文章从收藏夹失败", authorEmail, folderName, articleId);
      return null;
    }

    // 返回更新结果
    return result;
  } catch (error) {
    console.log("error", error);
    return null;
  }
};

// 查看作者的收藏夹中是否包含该文章，成功返回true，失败返回null
// 配合获取文章详情一起使用的，看看是否收藏了这篇文章
const isAuthorHasCollectArticle = async (authorEmail, articleId) => {
  try {
    // 使用模型
    const Author = mongoose.model("Author", AuthorSchema);

    // 找到作者信息
    const author = await isAuthorExist(authorEmail);

    // 作者不存在
    if (!author) {
      console.log("作者不存在", authorEmail);
      return null;
    }

    // 验证文章是否存在
    const article = await getArticleDetail(articleId);

    // 文章不存在
    if (!article) {
      console.log("文章不存在", articleId);
      return null;
    }

    // 查看文章是否在作者的收藏夹中
    const count = author.collectList.length;
    for (let i = 0; i < count; i++) {
      const folder = author.collectList[i];
      if (folder.collectItem.includes(articleId)) {
        return true;
      }
    }

    // 作者的收藏夹中没有该文章
    return false;
  } catch (error) {
    console.log("error", error);
    return null;
  }
};

// 删除作者
const deleteAuthor = async (authorId) => {
  try {
    // 使用模型
    const Author = mongoose.model("Author", AuthorSchema);

    const author = await getAuthorInfoById(authorId);

    // 判断作者是否存在
    if (!author) {
      console.log("作者不存在", authorId);
      return null;
    }

    // 获取作者的关注列表
    let unfollowAuthorResult = [];
    if (author.followers) {
      unfollowAuthorResult = author.followers.map(async (followersEmail) => {
        const result = await unfollowAuthor(authorId, followersEmail);
        if (!result) {
          console.log("取消粉丝关注失败", authorId, followersEmail);
        }
      });
    }

    // 等待删除完成
    await Promise.all(unfollowAuthorResult);

    // 获取作者的粉丝列表
    let fansUnfollowAuthorResult = [];
    if (author.fans) {
      fansUnfollowAuthorResult = author.fans.map(async (fansEmail) => {
        const unfollowResult = await unfollowAuthor(fansEmail, authorId);
        if (!unfollowResult) {
          console.log("取消粉丝关注失败", fansEmail, authorId);
        }
      });
    }

    // 等待删除完成
    await Promise.all(fansUnfollowAuthorResult);

    // 获取作者的文章列表
    let deleteArticleResult = [];
    if (author.articles) {
      deleteArticleResult = author.articles.map(async (articleId) => {
        const result = await deleteArticleById(articleId, authorId);
        if (!result) {
          console.log("删除文章失败", articleId);
        }
      });
    }

    // 等待删除完成
    await Promise.all(deleteArticleResult);

    // 获取作者的草稿列表
    let deleteDraftResult = [];
    if (author.drafts) {
      deleteDraftResult = author.drafts.map(async (draftId) => {
        const result = await deleteDraft(authorId, draftId);
        if (!result) {
          console.log("删除草稿失败", authorId, draftId);
        }
      });
    }

    // 等待删除完成
    await Promise.all(deleteDraftResult);

    // 删除作者
    const result = await Author.deleteOne({ email: author.email });

    console.log("author", author.email);
    console.log("result", result);
    // 删除失败
    if (!result.deletedCount) {
      console.log("删除作者失败aaaa", authorId);
      return null;
    }

    // 返回更新结果
    return result;
  } catch (error) {
    console.log(error);
    return false;
  }
};

// 导出API
module.exports = {
  deleteAuthor, // 删除作者
  followAuthor, // 关注操作
  unfollowAuthor, // 取消关注操作
  updataAuthorAvatar, // 修改作者头像地址
  addCollectFolder, // 添加收藏夹
  deleteCollectFolder, // 删除收藏夹
  addArticleToCollectFolder, // 向对应的收藏夹中添加文章
  isAuthorHasCollectArticle, // 查看作者的收藏夹中是否包含该文章
  deleteArticleFromCollectFolder, // 从对应的收藏夹中删除文章
  getAuthorArticleList, // 获取作者的文章列表
  getAuthorInfoById, // 获取作者信息
  addArticleToAuthor, // 添加文章到作者的文章列表
  deleteAuthorById, // 删除作者
  addAuthor, // 添加作者
  updataAuthorInfo, // 更新作者信息
  addLikeToAuthor, // 作者的点赞列表增加文章ID
  deleteLikeFromAuthor, // 作者的点赞列表删除文章ID
  deleteArticleFromAuthor, // 从作者的文章列表中删除文章
};
